Simplify `resolve_ws` API

diff --git a/src/cargo/ops/cargo_clean.rs b/src/cargo/ops/cargo_clean.rs
index 330d396dff52fd1016994b4cc8122f9e18bfcd0b..9627c902154eff880d681965d0a5f3c47928491e 100644 (file)
--- a/src/cargo/ops/cargo_clean.rs
+++ b/src/cargo/ops/cargo_clean.rs
@@ -3,7 +3,6 @@ use std::fs;
 use std::path::Path;
 
 use core::{Profiles, Workspace};
-use core::registry::PackageRegistry;
 use util::{CargoResult, human, ChainError, Config};
 use ops::{self, Context, BuildConfig, Kind, Unit};
 
@@ -28,9 +27,7 @@ pub fn clean(ws: &Workspace, opts: &CleanOptions) -> CargoResult<()> {
         return rm_rf(&target_dir);
     }
 
-    let mut registry = PackageRegistry::new(opts.config)?;
-    let resolve = ops::resolve_ws(&mut registry, ws)?;
-    let packages = ops::get_resolved_packages(&resolve, registry);
+    let (packages, resolve) = ops::resolve_ws(ws)?;
 
     let profiles = ws.profiles();
     let host_triple = opts.config.rustc()?.host.clone();

diff --git a/src/cargo/ops/cargo_fetch.rs b/src/cargo/ops/cargo_fetch.rs
index 1c30b0b7e8b81ac0cacb0b01f3749231de7e13d8..80dfdd0853b854ba454428d01a74fefd8accbe22 100644 (file)
--- a/src/cargo/ops/cargo_fetch.rs
+++ b/src/cargo/ops/cargo_fetch.rs
@@ -1,22 +1,12 @@
-use core::registry::PackageRegistry;
-use core::{PackageId, Resolve, PackageSet, Workspace};
+use core::{Resolve, PackageSet, Workspace};
 use ops;
 use util::CargoResult;
 
 /// Executes `cargo fetch`.
 pub fn fetch<'a>(ws: &Workspace<'a>) -> CargoResult<(Resolve, PackageSet<'a>)> {
-    let mut registry = PackageRegistry::new(ws.config())?;
-    let resolve = ops::resolve_ws(&mut registry, ws)?;
-    let packages = get_resolved_packages(&resolve, registry);
+    let (packages, resolve) = ops::resolve_ws(ws)?;
     for id in resolve.iter() {
         packages.get(id)?;
     }
     Ok((resolve, packages))
 }
-
-pub fn get_resolved_packages<'a>(resolve: &Resolve,
-                                 registry: PackageRegistry<'a>)
-                                 -> PackageSet<'a> {
-    let ids: Vec<PackageId> = resolve.iter().cloned().collect();
-    registry.get(&ids)
-}

diff --git a/src/cargo/ops/mod.rs b/src/cargo/ops/mod.rs
index ce6630cfdd36036be3995cbb589322a75bdbf4d0..b727456b6fe3cf4ee7d8141fac0a7d413574ae80 100644 (file)
--- a/src/cargo/ops/mod.rs
+++ b/src/cargo/ops/mod.rs
@@ -18,7 +18,7 @@ pub use self::cargo_package::{package, PackageOpts};
 pub use self::registry::{publish, registry_configuration, RegistryConfig};
 pub use self::registry::{registry_login, search, http_proxy_exists, http_handle};
 pub use self::registry::{modify_owners, yank, OwnersOptions, PublishOpts};
-pub use self::cargo_fetch::{fetch, get_resolved_packages};
+pub use self::cargo_fetch::fetch;
 pub use self::cargo_pkgid::pkgid;
 pub use self::resolve::{resolve_ws, resolve_dependencies, resolve_with_previous};
 pub use self::cargo_output_metadata::{output_metadata, OutputMetadataOptions, ExportInfo};

diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs
index 364335a77618e0a57353fea3f2face992173aeaa..1c1b21ca4c28e701e63a019361ea7005d2ed6e54 100644 (file)
--- a/src/cargo/ops/resolve.rs
+++ b/src/cargo/ops/resolve.rs
@@ -4,26 +4,19 @@ use core::{PackageId, PackageIdSpec, PackageSet, Source, SourceId, Workspace};
 use core::registry::PackageRegistry;
 use core::resolver::{self, Resolve, Method};
 use sources::PathSource;
-use util::{profile, human, CargoResult, ChainError};
 use ops;
+use util::{profile, human, CargoResult, ChainError};
 
 /// Resolve all dependencies for the specified `package` using the previous
 /// lockfile as a guide if present.
 ///
 /// This function will also write the result of resolution as a new
 /// lockfile.
-pub fn resolve_ws(registry: &mut PackageRegistry, ws: &Workspace)
-                   -> CargoResult<Resolve> {
-    let prev = ops::load_pkg_lockfile(ws)?;
-    let resolve = resolve_with_previous(registry, ws,
-                                        Method::Everything,
-                                        prev.as_ref(), None, &[])?;
-
-    // Avoid writing a lockfile if we are `cargo install`ing a non local package.
-    if ws.current_opt().map(|pkg| pkg.package_id().source_id().is_path()).unwrap_or(true) {
-        ops::write_pkg_lockfile(ws, &resolve)?;
-    }
-    Ok(resolve)
+pub fn resolve_ws<'a>(ws: &Workspace<'a>) -> CargoResult<(PackageSet<'a>, Resolve)> {
+    let mut registry = PackageRegistry::new(ws.config())?;
+    let resolve = resolve_with_registry(ws, &mut registry, true)?;
+    let packages = get_resolved_packages(&resolve, registry);
+    Ok((packages, resolve))
 }
 
 pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
@@ -39,15 +32,18 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
 
     let mut registry = PackageRegistry::new(ws.config())?;
 
+    let mut write_lockfile = true;
     if let Some(source) = source {
         if let Some(root_package) = ws.current_opt() {
+            // Avoid writing a lockfile if we are `cargo install`ing a non local package.
+            write_lockfile = false;
             registry.add_preloaded(root_package.package_id().source_id(), source);
         }
     }
 
     // First, resolve the root_package's *listed* dependencies, as well as
     // downloading and updating all remotes and such.
-    let resolve = resolve_ws(&mut registry, ws)?;
+    let resolve = resolve_with_registry(ws, &mut registry, write_lockfile)?;
 
     // Second, resolve with precisely what we're doing. Filter out
     // transitive dependencies if necessary, specify features, handle
@@ -79,12 +75,25 @@ pub fn resolve_dependencies<'a>(ws: &Workspace<'a>,
         }
     }
 
-    let packages = ops::get_resolved_packages(&resolved_with_overrides,
-                                              registry);
+    let packages = get_resolved_packages(&resolved_with_overrides, registry);
 
     Ok((packages, resolved_with_overrides))
 }
 
+fn resolve_with_registry(ws: &Workspace, registry: &mut PackageRegistry, write_lockfile: bool)
+                         -> CargoResult<Resolve> {
+    let prev = ops::load_pkg_lockfile(ws)?;
+    let resolve = resolve_with_previous(registry, ws,
+                                        Method::Everything,
+                                        prev.as_ref(), None, &[])?;
+
+    if write_lockfile {
+        ops::write_pkg_lockfile(ws, &resolve)?;
+    }
+    Ok(resolve)
+}
+
+
 /// Resolve all dependencies for a package using an optional previous instance
 /// of resolve to guide the resolution process.
 ///
@@ -258,3 +267,11 @@ fn add_overrides<'a>(registry: &mut PackageRegistry<'a>,
     }
     Ok(())
 }
+
+fn get_resolved_packages<'a>(resolve: &Resolve,
+                             registry: PackageRegistry<'a>)
+                             -> PackageSet<'a> {
+    let ids: Vec<PackageId> = resolve.iter().cloned().collect();
+    registry.get(&ids)
+}
+